home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d902.lha / Less / Source / source.lha / output.c < prev    next >
C/C++ Source or Header  |  1993-04-01  |  9KB  |  369 lines
  1. /*
  2.  * High level routines dealing with the output to the screen.
  3.  */
  4.  
  5. #include "less.h"
  6.  
  7.  
  8. public int errmsgs;     /* Count of messages displayed by error() */
  9.  
  10. extern int sigs;
  11. extern int sc_width, sc_height;
  12. extern int ul_width, ue_width;
  13. extern int so_width, se_width;
  14. extern int bo_width, be_width;
  15. #ifdef AMIGA
  16. extern int it_width, ie_width;
  17. extern int nv_width, ne_width;
  18. extern int nrow;  /* vertical screen size */
  19. extern int ShowCR;    /* suppress ^M characters? */
  20. #endif
  21. #ifdef EIGHTBIT
  22. extern int bs_mode;
  23. #endif
  24. extern int tabstop;
  25. extern int twiddle;
  26. extern int any_display;
  27. extern char *line;
  28. extern char *first_cmd;
  29.  
  30. /*
  31.  * Display the line which is in the line buffer.
  32.  */
  33. #ifdef __STDC__
  34. void put_line (void)
  35. #else
  36.         public void
  37. put_line()
  38. #endif
  39. {
  40. #ifdef AMIGA
  41.         register unsigned char *p;
  42. #else
  43.         register char *p;
  44. #endif
  45.         register int c;
  46.         register int column;
  47.         extern int auto_wrap, ignaw;
  48.  
  49.         if (sigs)
  50.                 /*
  51.                  * Don't output if a signal is pending.
  52.                  */
  53.                 return;
  54.  
  55.         if (line == NULL)
  56.                 line = (twiddle) ? "~" : "";
  57.  
  58.         column = 0;
  59. #ifdef AMIGA
  60.         for (p = (unsigned char *)line;  *p != '\0';  p++)
  61. #else
  62.         for (p = line;  *p != '\0';  p++)
  63. #endif
  64.         {
  65.                 switch (c = *p)
  66.                 {
  67.                 case UL_CHAR:
  68.                         ul_enter();
  69.                         column += ul_width;
  70.                         break;
  71.                 case UE_CHAR:
  72.                         ul_exit();
  73.                         column += ue_width;
  74.                         break;
  75.                 case BO_CHAR:
  76.                         bo_enter();
  77.                         column += bo_width;
  78.                         break;
  79.                 case BE_CHAR:
  80.                         bo_exit();
  81.                         column += be_width;
  82.                         break;
  83. #ifdef AMIGA
  84.                 case IT_CHAR:
  85.                         it_enter();
  86.                         column += it_width;
  87.                         break;
  88.                 case IE_CHAR:
  89.                         it_exit();
  90.                         column += ie_width;
  91.                         break;
  92.                 case NV_CHAR:
  93.                         nv_enter();
  94.                         column += nv_width;
  95.                         break;
  96.                 case NE_CHAR:
  97.                         nv_exit();
  98.                         column += ne_width;
  99.                         break;
  100. #endif
  101.                 case '\t':
  102.                         do
  103.                         {
  104.                                 putchr(' ');
  105.                                 column++;
  106.                         } while ((column % tabstop) != 0);
  107.                         break;
  108.                 case '\b':
  109. #ifdef EIGHTBIT
  110.                         if (bs_mode == BS_CONTROL)
  111.                         {
  112.                                 putchr('^');
  113.                                 putchr(carat_char(c));
  114.                                 column += 2;
  115.                                 break;
  116.                         }
  117. #endif
  118.                         putbs();
  119.                         column--;
  120.                         break;
  121.                 default:
  122. #ifdef EIGHTBIT
  123.                                 /* Control characters are still control
  124.                                  * characters.  Replace them with some-
  125.                                  * thing printable.
  126.                                  */
  127. #ifdef AMIGA
  128.                         if ( ShowCR || c != '\r' )
  129. #endif
  130.                         if (control_char(c))
  131.                         {
  132.                                 putchr('^');
  133.                                 putchr(carat_char(c));
  134.                                 column += 2;
  135.                         }
  136. #else
  137.                         if (c & 0200)
  138.                         {
  139.                                 /*
  140.                                  * Control characters arrive here as the
  141.                                  * normal character [carat_char(c)] with
  142.                                  * the 0200 bit set.  See pappend().
  143.                                  */
  144.                                 putchr('^');
  145.                                 putchr(c & 0177);
  146.                                 column += 2;
  147.                         }
  148. #endif
  149.                         else
  150.                         {
  151.                                 putchr(c);
  152.                                 column++;
  153.                         }
  154.                 }
  155.         }
  156.         if (column < sc_width || !auto_wrap || ignaw)
  157.                 putchr('\n');
  158. }
  159.  
  160. /*
  161.  * Is a given character a "control" character?
  162.  * {{ ASCII DEPENDENT }}
  163.  */
  164. #ifdef __STDC__
  165. int control_char (int c)
  166. #else
  167.         public int
  168. control_char(c)
  169.         int c;
  170. #endif
  171. {
  172. #ifdef EIGHTBIT
  173.         /* SAS says 0xff is a control character, for some reason */
  174.         return iscntrl(c) && c != 0xff;
  175. #else
  176.         return ( c < ' ' || c == '\177' );
  177. #endif
  178. }
  179.  
  180. /*
  181.  * Return the printable character used to identify a control character
  182.  * (printed after a carat; e.g. '\3' => "^C").
  183.  * {{ ASCII DEPENDENT }}
  184.  */
  185. #ifdef __STDC__
  186. int carat_char (int c)
  187. #else
  188.         public int
  189. carat_char(c)
  190.         int c;
  191. #endif
  192. {
  193.         return ((c == '\177') ? '?' : (c | 0100));
  194. }
  195.  
  196.  
  197. static char obuf[1024];
  198. static char *ob = obuf;
  199.  
  200. /*
  201.  * Flush buffered output.
  202.  */
  203. #ifdef __STDC__
  204. void flush (void)
  205. #else
  206.         public void
  207. flush()
  208. #endif
  209. {
  210. #ifdef AMIGA
  211.         ttwrite ( obuf, (long) (ob-obuf));
  212. #else
  213.         write(1, obuf, ob-obuf);
  214. #endif
  215.         ob = obuf;
  216. }
  217.  
  218. /*
  219.  * Discard buffered output.
  220.  */
  221. #ifdef __STDC__
  222. void dropout (void)
  223. #else
  224.         public void
  225. dropout()
  226. #endif
  227. {
  228.         ob = obuf;
  229. }
  230.  
  231. /*
  232.  * Output a character.
  233.  */
  234. #ifdef __STDC__
  235. void putchr (int c)
  236. #else
  237.         public void
  238. putchr(c)
  239.         int c;
  240. #endif
  241. {
  242.         if (ob >= &obuf[sizeof(obuf)])
  243.                 flush();
  244.         *ob++ = c;
  245. }
  246.  
  247. /*
  248.  * Output a string.
  249.  */
  250. #ifdef __STDC__
  251. void putstr (register char *s)
  252. #else
  253.         public void
  254. putstr(s)
  255.         register char *s;
  256. #endif
  257. {
  258.         while (*s != '\0')
  259.                 putchr(*s++);
  260. }
  261.  
  262. /*
  263.  * Output a message in the lower left corner of the screen
  264.  * and wait for carriage return.
  265.  */
  266.  
  267. static char return_to_continue[] = "  (press RETURN)";
  268.  
  269. #ifdef __STDC__
  270. void error (char *s)
  271. #else
  272.         public void
  273. error(s)
  274.         char *s;
  275. #endif
  276. {
  277.         register int c;
  278.         static char buf[2];
  279. #ifdef AMIGA
  280.         struct Screen *wbs;
  281. #endif
  282.  
  283.         errmsgs++;
  284. #ifdef AMIGA
  285.         /* nrow tells us if the window has been opened yet.
  286.            any_display tells us if we have initialized reading a file yet.
  287.            We display error in the window if there is one, else to Output(),
  288.            which does not, however, exist in a WB environment.  Thus
  289.            if there is no Less window, also Beep the display.
  290.         */
  291.         if ( nrow < 2 )
  292. #else
  293.         if (!any_display)
  294. #endif
  295.         {
  296.                 /*
  297.                  * Nothing has been displayed yet.
  298.                  * Output this message on error output (file
  299.                  * descriptor 2) and don't wait for a keystroke
  300.                  * to continue.
  301.                  *
  302.                  * This has the desirable effect of producing all
  303.                  * error messages on error output if standard output
  304.                  * is directed to a file.  It also does the same if
  305.                  * we never produce any real output; for example, if
  306.                  * the input file(s) cannot be opened.  If we do
  307.                  * eventually produce output, code in edit() makes
  308.                  * sure these messages can be seen before they are
  309.                  * overwritten or scrolled away.
  310.                  */
  311. #ifdef AMIGA
  312.                 /* If the window is too small, s may be NULL on Amiga */
  313.                 if ( s )
  314.                     Write ( Output(), s, strlen(s) );
  315.                 else
  316.                     Write ( Output(), "Error", 5 );
  317.                 Write ( Output(), "\n", 1 );
  318.                 wbs = MyFindWB ();
  319.                 DisplayBeep ( wbs );
  320.                 MyFreeWB (wbs);
  321. #else
  322.                 write(2, s, strlen(s));
  323.                 write(2, "\n", 1);
  324. #endif
  325.                 return;
  326.         }
  327.  
  328.         lower_left();
  329.         clear_eol();
  330.         so_enter();
  331. #ifdef AMIGA
  332.         if ( s )
  333. #endif
  334.         putstr(s);
  335.         putstr(return_to_continue);
  336.         so_exit();
  337.  
  338. #if ONLY_RETURN
  339.         while ((c = getchr()) != '\n' && c != '\r')
  340.                 bell();
  341. #else
  342.         c = getchr();
  343.         if (c != '\n' && c != '\r' && c != ' ')
  344.         {
  345.                 buf[0] = c;
  346.                 first_cmd = buf;
  347.         }
  348. #endif
  349.         lower_left();
  350.  
  351. #ifdef AMIGA
  352.         if ( s &&
  353.                 strlen(s) + sizeof(return_to_continue) +
  354.                 so_width + se_width + 1 > sc_width
  355.                 )
  356. #else
  357.         if (strlen(s) + sizeof(return_to_continue) +
  358.                 so_width + se_width + 1 > sc_width)
  359. #endif
  360.                 /*
  361.                  * Printing the message has probably scrolled the screen.
  362.                  * {{ Unless the terminal doesn't have auto margins,
  363.                  *    in which case we just hammered on the right margin. }}
  364.                  */
  365.                 repaint();
  366.  
  367.         flush();
  368. }
  369.